﻿package zf.data.tools
{
	/**
	 * 正则表达式扩展，提供字符串的类型检查函数等。
	 * @author mike.zhang
	 * @langversion 3.0 
	 * @playerversion Flash 9 
	 */
	public class RegExpAPI
	{
		/**
		 * 忽略大小字母比较字符是否相等; 
		 * @param char1 字符串1
		 * @param char2 字符串2
		 * @return 相同返回true
		 * 
		 */
		public static  function equalsIgnoreCase (char1:String,char2:String):Boolean
		{
			return char1.toLowerCase() == char2.toLowerCase();
		}

		/**
		 * 是否为Email地址
		 * @param char 待检测字符串
		 * @return 是返回true
		 * 
		 */
		public static  function isEmail (char:String):Boolean
		{
			if (char == null)
			{
				return false;
			}
			char=trim(char);
			var pattern:RegExp=/(\w|[_.\-])+@((\w|-)+\.)+\w{2,4}+/;
			var result:Object=pattern.exec(char);
			if (result == null)
			{
				return false;
			}
			return true;
		}

		/**
		 * 是否是数值字符串
		 * @param char 待检测字符串
		 * @return 是返回true
		 * 
		 */
		public static  function isNumber (char:String):Boolean
		{
			if (char == null)
			{
				return false;
			}
			return ! isNaN(Number(char));
		}

		/**
		 * 是否为Double型数据
		 * @param char 待检测字符串
		 * @return 是返回true
		 * 
		 */
		public static  function isDouble (char:String):Boolean
		{
			char=trim(char);
			var pattern:RegExp=/^[-\+]?\d+(\.\d+)?$/;
			var result:Object=pattern.exec(char);
			if (result == null)
			{
				return false;
			}
			return true;
		}
		/**
		 * 是否为int型数据
		 * @param char 待检测字符串
		 * @return 是返回true
		 * 
		 */
		public static  function isInteger (char:String):Boolean
		{
			if (char == null)
			{
				return false;
			}
			char=trim(char);
			var pattern:RegExp=/^[-\+]?\d+$/;
			var result:Object=pattern.exec(char);
			if (result == null)
			{
				return false;
			}
			return true;
		}
		/**
		 * 是否为英文
		 * @param char 待检测字符串
		 * @return 是返回true
		 * 
		 */
		public static  function isEnglish (char:String):Boolean
		{
			if (char == null)
			{
				return false;
			}
			char=trim(char);
			var pattern:RegExp=/^[A-Za-z]+$/;
			var result:Object=pattern.exec(char);
			if (result == null)
			{
				return false;
			}
			return true;
		}
		/**
		 * 是否为中文
		 * @param char 待检测字符串
		 * @return 是返回true
		 * 
		 */
		public static  function isChinese (char:String):Boolean
		{
			if (char == null)
			{
				return false;
			}
			char=trim(char);
			var pattern:RegExp = /^[\u0391-\uFFE5]+$/; ;
			var result:Object=pattern.exec(char);
			if (result == null)
			{
				return false;
			}
			return true;
		}
		/**
		 * 是否为双字节
		 * @param char 待检测字符串
		 * @return 是返回true
		 * 
		 */
		public static  function isDoubleChar (char:String):Boolean
		{
			if (char == null)
			{
				return false;
			}
			char=trim(char);
			var pattern:RegExp=/^[^\x00-\xff]+$/;
			var result:Object=pattern.exec(char);
			if (result == null)
			{
				return false;
			}
			return true;
		}

		/**
		 * 是否含有中文字符
		 * @param char 待检测字符串
		 * @return 是返回true
		 * 
		 */
		public static  function hasChineseChar (char:String):Boolean
		{
			if (char == null)
			{
				return false;
			}
			char=trim(char);
			var pattern:RegExp=/[^\x00-\xff]/;
			var result:Object=pattern.exec(char);
			if (result == null)
			{
				return false;
			}
			return true;
		}

		/**
		 * 是否注册字符 
		 * @param char 待检测的字符串
		 * @param len 长度
		 * @return 是返回true
		 * 
		 */
		public static  function hasAccountChar (char:String,len:uint=15):Boolean
		{
			if (char == null)
			{
				return false;
			}
			if (len < 10)
			{
				len=15;
			}
			char=trim(char);
			var pattern:RegExp=new RegExp("^[a-zA-Z0-9][a-zA-Z0-9_-]{0," + len + "}$","");
			var result:Object=pattern.exec(char);
			if (result == null)
			{
				return false;
			}
			return true;
		}

		/**
		 * 是否URL地址
		 * @param char 待检测字符串
		 * @return 是返回true
		 * 
		 */
		public static  function isURL (char:String):Boolean
		{
			if (char == null)
			{
				return false;
			}
			char=trim(char).toLowerCase();
			var pattern:RegExp=/^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$/;
			var result:Object=pattern.exec(char);
			if (result == null)
			{
				return false;
			}
			return true;
		}
		/**
		 * 是否为空白
		 * @param char 待检测字符串
		 * @return 是返回true
		 * 
		 */
		public static  function isWhitespace (char:String):Boolean
		{
			switch (char)
			{
				case " " :
				case "\t" :
				case "\r" :
				case "\n" :
				case "\f" :
					return true;
				default :
					return false;
			}
		}

		/**
		 * 去左右空格
		 * @param char 待处理的字符串
		 * @return 处理过的字符串
		 * 
		 */
		public static  function trim (char:String):String
		{
			if (char == null)
			{
				return null;
			}
			return rtrim(ltrim(char));
		}

		/**
		 * 去左空格 
		 * @param char 待处理的字符串
		 * @return 处理过的字符串
		 * 
		 */
		public static  function ltrim (char:String):String
		{
			if (char == null)
			{
				return null;
			}
			var pattern:RegExp=/^\s*/;
			return char.replace(pattern,"");
		}
		/**
		 * 去右空格 
		 * @param char 待处理的字符串
		 * @return 处理过的字符串
		 * 
		 */
		public static  function rtrim (char:String):String
		{
			if (char == null)
			{
				return null;
			}
			var pattern:RegExp=/\s*$/;
			return char.replace(pattern,"");
		}

		/**
		 * 字符串 char 的前缀是否为 prefix 
		 * @param char 待检测的字符串
		 * @param prefix 前缀字符串
		 * @return 是返回true
		 * 
		 */
		public static  function beginsWith (char:String,prefix:String):Boolean
		{
			return prefix == char.substring(0,prefix.length);
		}
		/**
		 * 字符串 char 的后缀是否为 prefix 
		 * @param char 待检测的字符串
		 * @param suffix 后缀字符串
		 * @return 是返回true
		 * 
		 */
		public static  function endsWith (char:String,suffix:String):Boolean
		{
			return (suffix == char.substring(char.length - suffix.length));
		}

		/**
		 * 去除制定的字符串
		 * @param char 要处理的字符串
		 * @param remove 要去除的字符串
		 * @return 处理过的新字符串
		 * 
		 */
		public static  function remove (char:String,remove:String):String
		{
			return replace(char,remove,"");
		}
		/**
		 * 替换制定的字符串 
		 * @param char 要处理的字符串
		 * @param replace 要删除的字符串
		 * @param replaceWith 替换的字符串
		 * @return 处理过的新字符串
		 * 
		 */
		public static  function replace (char:String,replace:String,replaceWith:String):String
		{
			return char.split(replace).join(replaceWith);
		}

		/**
		 * 将UTF16编码转为UTF8编码 
		 * @param char 要转化的字符
		 * @return 处理过的字符串
		 * 
		 */
		public static  function utf16to8 (char:String):String
		{
			var out:Array=new Array  ;
			var len:uint=char.length;
			for (var i:uint=0; i < len; i++)
			{
				var c:int=char.charCodeAt(i);
				if (c >= 0x0001 && c <= 0x007F)
				{
					out[i]=char.charAt(i);
				}
				else if (c > 0x07FF)
				{
					out[i]=String.fromCharCode(0xE0 | c >> 12 & 0x0F,0x80 | c >> 6 & 0x3F,0x80 | c >> 0 & 0x3F);
				}
				else
				{
					out[i]=String.fromCharCode(0xC0 | c >> 6 & 0x1F,0x80 | c >> 0 & 0x3F);
				}
			}
			return out.join('');
		}
		/**
		 * 将UTF8编码转为UTF16编码 
		 * @param char 要转化的字符
		 * @return 处理过的字符串
		 * 
		 */
		public static  function utf8to16 (char:String):String
		{
			var out:Array=new Array  ;
			var len:uint=char.length;
			var i:uint=0;
			var char2:int,char3:int;
			while (i < len)
			{
				var c:int=char.charCodeAt(i++);
				switch (c >> 4)
				{
					case 0 :
					case 1 :
					case 2 :
					case 3 :
					case 4 :
					case 5 :
					case 6 :
					case 7 :
						// 0xxxxxxx
						out[out.length]=char.charAt(i - 1);
						break;
					case 12 :
					case 13 :
						// 110x xxxx   10xx xxxx
						char2=char.charCodeAt(i++);
						out[out.length]=String.fromCharCode(c & 0x1F << 6 | char2 & 0x3F);
						break;
					case 14 :
						// 1110 xxxx  10xx xxxx  10xx xxxx
						char2=char.charCodeAt(i++);
						char3=char.charCodeAt(i++);
						out[out.length]=String.fromCharCode(c & 0x0F << 12 | char2 & 0x3F << 6 | char3 & 0x3F << 0);
						break;
				}
			}
			return out.join('');
		}
	}
}